/**
 * 基于Web Audio API的纯JavaScript音频引擎
 */

class WebAudioEngine {
    constructor() {
        this.audioContext = null;
        this.audioBuffer = null;
        this.sourceNode = null;
        this.gainNode = null;
        this.isPlaying = false;
        this.isPaused = false;
        this.startTime = 0;
        this.pauseTime = 0;
        this.duration = 0;
        this.volume = 0.7;
        this.currentTrack = null;
        this.playlist = [];
        this.currentIndex = -1;

        // 均衡器相关属性
        this.equalizer = null;
        this.equalizerEnabled = false;
        this.onEqualizerChanged = null;

        // 事件回调
        this.onTrackChanged = null;
        this.onPlaybackStateChanged = null;
        this.onPositionChanged = null;
        this.onVolumeChanged = null;

        // 进度更新定时器
        this.progressTimer = null;

        // 封面对象URL管理
        this.coverObjectUrls = new Set();
        console.log('🎵 Web Audio Engine 初始化');
    }

    /**
     * 初始化音频上下文
     */
    async initialize() {
        try {
            // 创建音频上下文
            this.audioContext = new (window.AudioContext || window.webkitAudioContext)();

            // 创建增益节点用于音量控制
            this.gainNode = this.audioContext.createGain();
            this.gainNode.connect(this.audioContext.destination);
            this.gainNode.gain.value = this.volume;

            this.initializeEqualizer();

            console.log('✅ Web Audio Engine 初始化成功');
            return true;
        } catch (error) {
            console.error('❌ Web Audio Engine 初始化失败:', error);
            return false;
        }
    }

    /**
     * 加载音频文件
     */
    async loadTrack(filePath) {
        try {
            console.log(`🔄 加载音频文件: ${filePath}`);
            this.stop();

            // 读取文件 - 支持多种方式
            let arrayBuffer;

            if (window.electronAPI && window.electronAPI.readAudioFile) {
                console.log('🔄 使用Electron API读取文件');
                arrayBuffer = await window.electronAPI.readAudioFile(filePath);
            } else {
                // 回退到fetch方式
                const fileUrl = filePath.startsWith('file://') ? filePath : `file:///${filePath.replace(/\\/g, '/')}`;
                const response = await fetch(fileUrl);
                if (!response.ok) {
                    throw new Error(`Failed to fetch audio file: ${response.status}`);
                }
                arrayBuffer = await response.arrayBuffer();
            }

            // 解码音频数据
            this.audioBuffer = await this.audioContext.decodeAudioData(arrayBuffer);
            const webAudioDuration = this.audioBuffer.duration;

            const metadata = await this.getTrackMetadata(filePath);
            this.duration = (metadata.duration && metadata.duration > 0) ? metadata.duration : webAudioDuration;

            // 处理内嵌封面
            let coverUrl = null;
            if (metadata.cover && metadata.cover.data) {
                try {
                    if (window.embeddedCoverManager) {
                        const coverResult = window.embeddedCoverManager.convertCoverToUrl(metadata.cover);
                        if (coverResult.success && typeof coverResult.url === 'string') {
                            coverUrl = coverResult.url;
                            this.coverObjectUrls.add(coverUrl);
                        }
                    } else {
                        // 直接处理封面数据
                        const coverBlob = new Blob([metadata.cover.data], {
                            type: `image/${metadata.cover.format.toLowerCase()}`
                        });
                        coverUrl = URL.createObjectURL(coverBlob);
                        this.coverObjectUrls.add(coverUrl);
                    }
                } catch (error) {
                    console.error('封面处理失败:', error);
                }
            }

            // 验证封面URL格式
            if (coverUrl && typeof coverUrl !== 'string') {
                coverUrl = null;
            }

            // 更新当前曲目信息
            this.currentTrack = {
                filePath: filePath,
                title: metadata.title,
                artist: metadata.artist,
                album: metadata.album,
                duration: this.duration,
                bitrate: metadata.bitrate,
                sampleRate: metadata.sampleRate,
                year: metadata.year,
                genre: metadata.genre,
                track: metadata.track,
                disc: metadata.disc,
                cover: coverUrl
            };

            console.log(`✅ 音频解码成功: Web Audio时长 ${webAudioDuration.toFixed(2)}s, 元数据时长 ${metadata.duration || 0}s`);
            console.log(`✅ 使用时长: ${this.duration.toFixed(2)}s`);
            console.log(`✅ 音频文件加载成功: ${this.currentTrack.title}`);

            // 触发事件
            if (this.onTrackChanged) {
                this.onTrackChanged(this.currentTrack);
            }

            // 触发时长更新事件
            // if (this.onDurationChanged) {
            //     this.onDurationChanged(filePath, this.duration);
            // }
            return true;
        } catch (error) {
            console.error('❌ 音频文件加载失败:', error);
            return false;
        }
    }

    /**
     * 播放音频
     */
    async play() {
        try {
            if (!this.audioBuffer) {
                console.warn('⚠️ 没有加载音频文件');
                return false;
            }

            // 恢复音频上下文（用户交互后需要）
            if (this.audioContext.state === 'suspended') {
                await this.audioContext.resume();
            }

            // 如果已经在播放且未暂停，不重复播放
            if (this.isPlaying && !this.isPaused) {
                console.log('⚠️ 音频已在播放中');
                return true;
            }

            console.log(`🔄 准备播放，当前状态: isPlaying=${this.isPlaying}, isPaused=${this.isPaused}, pauseTime=${this.pauseTime}`);

            // 停止当前播放
            if (this.sourceNode) {
                try {
                    this.sourceNode.onended = null; // 移除回调避免意外触发
                    this.sourceNode.stop();
                    this.sourceNode.disconnect();
                } catch (e) {
                    // 忽略已停止的错误
                }
                this.sourceNode = null;
            }

            // 创建新的音频源
            this.sourceNode = this.audioContext.createBufferSource();
            this.sourceNode.buffer = this.audioBuffer;

            // 连接到音频链
            this.connectSourceToChain();

            // 设置播放结束回调
            this.sourceNode.onended = () => {
                if (this.isPlaying) {
                    this.onTrackEnded();
                }
            };

            // 开始播放
            const offset = this.isPaused ? this.pauseTime : 0;

            // 确保偏移量在有效范围内
            const validOffset = Math.max(0, Math.min(offset, this.duration - 0.1));
            console.log(`▶️ 开始播放，原始偏移量: ${offset.toFixed(2)}s, 有效偏移量: ${validOffset.toFixed(2)}s, 音频时长: ${this.duration.toFixed(2)}s`);

            try {
                this.sourceNode.start(0, validOffset);
                this.startTime = this.audioContext.currentTime - validOffset;

                // 如果偏移量被调整了，更新pauseTime
                if (validOffset !== offset) {
                    this.pauseTime = validOffset;
                    console.log(`🔄 偏移量已调整为: ${validOffset.toFixed(2)}s`);
                }
            } catch (startError) {
                console.error('❌ 音频源启动失败:', startError);
                console.log('🔄 尝试从头开始播放');

                // 重新创建音频源并从头开始
                this.sourceNode = this.audioContext.createBufferSource();
                this.sourceNode.buffer = this.audioBuffer;

                // 连接到音频链
                this.connectSourceToChain();
                this.sourceNode.onended = () => {
                    if (this.isPlaying) {
                        this.onTrackEnded();
                    }
                };

                this.sourceNode.start(0, 0);
                this.startTime = this.audioContext.currentTime;
                this.pauseTime = 0;
                this.isPaused = false;
            }

            this.isPlaying = true;
            this.isPaused = false;

            // 开始进度更新
            this.startProgressTimer();

            console.log('✅ 播放成功启动');

            // 触发事件
            if (this.onPlaybackStateChanged) {
                console.log('🔄 Web Audio Engine: 触发播放状态变化事件');
                this.onPlaybackStateChanged(true);
            } else {
                console.warn('⚠️ Web Audio Engine: onPlaybackStateChanged 回调未设置');
            }

            return true;
        } catch (error) {
            console.error('❌ 播放失败:', error);
            return false;
        }
    }

    /**
     * 暂停播放
     */
    pause() {
        try {
            if (!this.isPlaying && !this.sourceNode) {
                console.log('⚠️ 音频未在播放且无音频源，无法暂停');
                return false;
            }

            if (!this.isPlaying) {
                console.log('⚠️ 状态显示未播放，但仍尝试暂停');
            }

            // 记录暂停位置
            const currentPosition = this.audioContext.currentTime - this.startTime;
            this.pauseTime = Math.max(0, Math.min(currentPosition, this.duration - 0.1));
            console.log(`🔄 暂停位置计算: currentTime=${this.audioContext.currentTime.toFixed(2)}, startTime=${this.startTime.toFixed(2)}, 计算位置=${currentPosition.toFixed(2)}, 最终位置=${this.pauseTime.toFixed(2)}`);

            // 如果计算出的位置异常，使用当前进度
            if (this.pauseTime < 0 || this.pauseTime >= this.duration) {
                const fallbackPosition = this.getPosition();
                console.log(`⚠️ 暂停位置异常，使用备用位置: ${fallbackPosition.toFixed(2)}s`);
                this.pauseTime = Math.max(0, Math.min(fallbackPosition, this.duration - 0.1));
            }

            // 停止音频源（不触发onended事件）
            if (this.sourceNode) {
                try {
                    // 移除onended回调，避免触发自动播放下一首
                    this.sourceNode.onended = null;
                    this.sourceNode.stop();
                    this.sourceNode.disconnect();
                } catch (e) {
                }
                this.sourceNode = null;
            }

            this.isPlaying = false;
            this.isPaused = true;

            // 停止进度更新
            this.stopProgressTimer();
            console.log(`⏸️ 暂停播放，位置: ${this.pauseTime.toFixed(2)}s`);

            // 触发事件
            if (this.onPlaybackStateChanged) {
                console.log('🔄 Web Audio Engine: 触发暂停状态变化事件');
                this.onPlaybackStateChanged(false);
            } else {
                console.warn('⚠️ Web Audio Engine: onPlaybackStateChanged 回调未设置');
            }
            return true;
        } catch (error) {
            console.error('❌ 暂停失败:', error);
            return false;
        }
    }

    /**
     * 停止播放
     */
    stop() {
        try {
            // 停止音频源（不触发onended事件）
            if (this.sourceNode) {
                try {
                    // 移除onended回调，避免触发自动播放下一首
                    this.sourceNode.onended = null;
                    this.sourceNode.stop();
                    this.sourceNode.disconnect();
                } catch (e) {
                }
                this.sourceNode = null;
            }

            this.isPlaying = false;
            this.isPaused = false;
            this.startTime = 0;
            this.pauseTime = 0;

            // 停止进度更新
            this.stopProgressTimer();
            console.log('⏹️ 停止播放');

            // 触发事件
            if (this.onPlaybackStateChanged) {
                this.onPlaybackStateChanged(false);
            }

            // 触发位置重置事件
            if (this.onPositionChanged) {
                this.onPositionChanged(0);
            }
            return true;
        } catch (error) {
            console.error('❌ 停止失败:', error);
            return false;
        }
    }

    /**
     * 清理封面对象URL
     */
    cleanupCoverUrls() {
        for (const url of this.coverObjectUrls) {
            try {
                URL.revokeObjectURL(url);
            } catch (error) {
                console.warn('⚠️ 清理封面URL失败:', error);
            }
        }
        this.coverObjectUrls.clear();
        console.log('🧹 封面URL清理完成');
    }

    /**
     * 跳转到指定位置
     */
    async seek(position) {
        try {
            if (!this.audioBuffer) {
                console.warn('⚠️ 没有加载音频文件，无法跳转');
                return false;
            }

            const wasPlaying = this.isPlaying;

            // 停止当前播放（但不触发onended事件）
            if (this.sourceNode) {
                try {
                    // 临时移除onended回调，避免触发自动播放下一首
                    this.sourceNode.onended = null;
                    this.sourceNode.stop();
                    this.sourceNode.disconnect();
                } catch (e) {
                }
                this.sourceNode = null;
            }

            // 停止进度更新
            this.stopProgressTimer();

            // 设置新位置
            this.pauseTime = Math.max(0, Math.min(position, this.duration));
            this.isPaused = true;
            this.isPlaying = false;
            console.log(`⏭️ 跳转到: ${position.toFixed(2)}s`);

            // 如果之前在播放，继续播放
            if (wasPlaying) {
                await this.play();
            }

            // 触发位置更新事件
            if (this.onPositionChanged) {
                this.onPositionChanged(this.pauseTime);
            }
            return true;
        } catch (error) {
            console.error('❌ 跳转失败:', error);
            return false;
        }
    }

    /**
     * 设置音量
     */
    setVolume(volume) {
        try {
            this.volume = Math.max(0, Math.min(1, volume));

            if (this.gainNode) {
                // 使用线性渐变避免音量突变
                this.gainNode.gain.setValueAtTime(this.volume, this.audioContext.currentTime);
            }

            console.log(`🔊 音量设置为: ${(this.volume * 100).toFixed(0)}%`);

            // 触发事件
            if (this.onVolumeChanged) {
                this.onVolumeChanged(this.volume);
            }

            return true;
        } catch (error) {
            console.error('❌ 音量设置失败:', error);
            return false;
        }
    }

    /**
     * 获取当前音量
     */
    getVolume() {
        return this.volume;
    }

    /**
     * 获取当前播放位置
     */
    getPosition() {
        if (!this.isPlaying && !this.isPaused) {
            return 0;
        }

        if (this.isPaused) {
            return this.pauseTime;
        }

        return this.audioContext.currentTime - this.startTime;
    }

    /**
     * 获取音频时长
     */
    getDuration() {
        return this.duration;
    }

    /**
     * 获取当前曲目信息
     */
    getCurrentTrack() {
        return this.currentTrack;
    }

    /**
     * 设置播放列表
     */
    setPlaylist(tracks, startIndex = -1) {
        this.playlist = tracks;
        this.currentIndex = startIndex; // 设置起始索引

        console.log(`📋 播放列表设置: ${tracks.length}首歌曲，起始索引: ${startIndex}`);
        if (tracks.length > 0) {
            console.log('📋 第一首歌曲信息:', tracks[0]);
            if (startIndex >= 0 && startIndex < tracks.length) {
                console.log('📋 当前选中歌曲:', tracks[startIndex]);
            }
            console.log('📋 歌曲数据结构:', {
                hasFilePath: !!tracks[0].filePath,
                hasTitle: !!tracks[0].title,
                hasArtist: !!tracks[0].artist,
                keys: Object.keys(tracks[0])
            });
        }

        return true;
    }

    /**
     * 播放下一首
     */
    async nextTrack() {
        if (this.playlist.length === 0) {
            console.log('⚠️ 播放列表为空');
            return false;
        }

        // 如果当前索引为-1，说明还没有开始播放，这种情况不应该发生
        if (this.currentIndex === -1) {
            console.warn('⚠️ 当前索引为-1，无法切换到下一首');
            return false;
        }

        // 切换到下一首
        this.currentIndex = (this.currentIndex + 1) % this.playlist.length;
        const nextTrack = this.playlist[this.currentIndex];

        // 获取文件路径，支持多种数据结构
        const filePath = nextTrack.filePath || nextTrack.path || nextTrack;

        if (!filePath) {
            console.error('❌ 下一首歌曲文件路径为空:', nextTrack);
            return false;
        }

        console.log(`⏭️ 切换到下一首 (索引 ${this.currentIndex}): ${nextTrack.title || filePath}`);

        const loadResult = await this.loadTrack(filePath);
        if (loadResult) {
            // 自动开始播放
            return await this.play();
        }
        return false;
    }

    /**
     * 播放上一首
     */
    async previousTrack() {
        if (this.playlist.length === 0) {
            console.log('⚠️ 播放列表为空');
            return false;
        }

        // 如果当前索引为-1，说明还没有开始播放，这种情况不应该发生
        if (this.currentIndex === -1) {
            console.warn('⚠️ 当前索引为-1，无法切换到上一首');
            return false;
        }

        // 切换到上一首
        this.currentIndex = this.currentIndex > 0 ? this.currentIndex - 1 : this.playlist.length - 1;
        const prevTrack = this.playlist[this.currentIndex];

        // 获取文件路径，支持多种数据结构
        const filePath = prevTrack.filePath || prevTrack.path || prevTrack;

        if (!filePath) {
            console.error('❌ 上一首歌曲文件路径为空:', prevTrack);
            return false;
        }

        console.log(`⏮️ 切换到上一首 (索引 ${this.currentIndex}): ${prevTrack.title || filePath}`);

        const loadResult = await this.loadTrack(filePath);
        if (loadResult) {
            // 自动开始播放
            return await this.play();
        }
        return false;
    }

    /**
     * 从文件路径提取标题
     */
    extractTitleFromPath(filePath) {
        const fileName = filePath.split(/[/\\]/).pop();
        return fileName.replace(/\.[^/.]+$/, ''); // 移除扩展名
    }

    async getTrackMetadata(filePath) {
        if (window.electronAPI && window.electronAPI.library) {
            console.log('🔄 从主进程获取音频元数据...');
            const metadata = await window.electronAPI.library.getTrackMetadata(filePath);
            if (metadata) {
                console.log(`✅ 成功获取元数据: ${metadata.title} - ${metadata.artist}`);
                return {
                    title: metadata.title || '未知标题',
                    artist: metadata.artist || '未知艺术家',
                    album: metadata.album || '未知专辑',
                    duration: metadata.duration || 0,
                    bitrate: metadata.bitrate || 0,
                    sampleRate: metadata.sampleRate || 0,
                    year: metadata.year,
                    genre: metadata.genre,
                    track: metadata.track,
                    disc: metadata.disc,
                    cover: metadata.cover
                };
            }
        }
    }

    /**
     * 曲目播放结束处理
     */
    onTrackEnded() {
        console.log('🔚 曲目播放结束');
        this.isPlaying = false;
        this.isPaused = false;

        // 自动播放下一首（nextTrack方法内部已经调用了play，不需要重复调用）
        if (this.playlist.length > 0) {
            setTimeout(async () => {
                await this.nextTrack();
            }, 500);
        }
    }

    /**
     * 开始进度更新定时器
     */
    startProgressTimer() {
        this.stopProgressTimer();

        this.progressTimer = setInterval(() => {
            if (this.isPlaying && this.onPositionChanged) {
                this.onPositionChanged(this.getPosition());
            }
        }, 1000);
    }

    /**
     * 停止进度更新定时器
     */
    stopProgressTimer() {
        if (this.progressTimer) {
            clearInterval(this.progressTimer);
            this.progressTimer = null;
        }
    }

    /**
     * 初始化均衡器
     */
    initializeEqualizer() {
        console.log('🎛️ 开始初始化均衡器...');
        if (!this.audioContext) {
            console.error('❌ 音频上下文未初始化，无法创建均衡器');
            return;
        }

        try {
            console.log('🎛️ 创建AudioEqualizer实例...');
            this.equalizer = new AudioEqualizer(this.audioContext);
            console.log('✅ 均衡器初始化成功');
            console.log(`🎛️ 均衡器滤波器数量: ${this.equalizer.filters.length}`);
        } catch (error) {
            console.error('❌ 均衡器初始化失败:', error);
            this.equalizer = null;
        }
    }

    /**
     * 获取均衡器实例
     */
    getEqualizer() {
        return this.equalizer;
    }

    /**
     * 启用/禁用均衡器
     */
    setEqualizerEnabled(enabled) {
        console.log(`🎛️ 设置均衡器状态: ${enabled} (当前: ${this.equalizerEnabled})`);

        // 如果状态没有变化，直接返回
        if (this.equalizerEnabled === enabled) {
            console.log(`ℹ️ 均衡器状态已经是 ${enabled}，无需更改`);
            return;
        }

        this.equalizerEnabled = enabled;

        // 如果音频正在播放且sourceNode存在，立即重新连接音频链
        if (this.sourceNode && this.isPlaying) {
            console.log('🔄 音频正在播放，立即重新连接音频链以应用均衡器状态变化');
            this.reconnectAudioChain();
        } else {
            console.log('🎛️ 音频未播放或sourceNode不存在，均衡器状态将在下次播放时生效');
        }

        if (this.onEqualizerChanged) {
            this.onEqualizerChanged({enabled});
        }

        console.log(`✅ 均衡器${enabled ? '已启用' : '已禁用'}`);
    }

    /**
     * 连接音频源到音频链
     */
    connectSourceToChain() {
        console.log('🔗 开始连接音频源到音频链...');
        console.log(`🔗 sourceNode存在: ${!!this.sourceNode}`);
        console.log(`🔗 equalizer存在: ${!!this.equalizer}`);
        console.log(`🔗 equalizerEnabled: ${this.equalizerEnabled}`);
        console.log(`🔗 gainNode存在: ${!!this.gainNode}`);

        if (!this.sourceNode) {
            console.warn('⚠️ sourceNode不存在，无法连接音频链');
            return;
        }

        // 确保gainNode连接到destination
        try {
            // 检查gainNode是否已连接到destination，如果没有则连接
            this.gainNode.disconnect();
            this.gainNode.connect(this.audioContext.destination);
            console.log('✅ gainNode -> destination 连接确保');
        } catch (error) {
            console.warn('⚠️ gainNode连接确保失败:', error);
        }

        if (this.equalizer && this.equalizerEnabled) {
            console.log('🔗 使用均衡器路径: sourceNode -> equalizer.input -> [滤波器链] -> equalizer.output -> gainNode -> destination');
            console.log(`🔗 equalizer.input存在: ${!!this.equalizer.input}`);
            console.log(`🔗 equalizer.output存在: ${!!this.equalizer.output}`);

            try {
                // 确保均衡器输出连接到gainNode
                this.equalizer.output.disconnect();
                this.equalizer.output.connect(this.gainNode);
                console.log('✅ equalizer.output -> gainNode 连接确保');

                // 音频源 -> 均衡器输入
                this.sourceNode.connect(this.equalizer.input);
                console.log('✅ sourceNode -> equalizer.input 连接成功');

            } catch (error) {
                console.error('❌ 均衡器音频链连接失败:', error);
                // 回退到直接连接
                try {
                    this.sourceNode.connect(this.gainNode);
                    console.log('🔄 回退到直接连接: sourceNode -> gainNode');
                } catch (fallbackError) {
                    console.error('❌ 回退连接也失败:', fallbackError);
                }
            }
        } else {
            console.log('🔗 使用直接路径: sourceNode -> gainNode -> destination');
            try {
                // 音频源 -> 增益节点
                this.sourceNode.connect(this.gainNode);
                console.log('✅ sourceNode -> gainNode 连接成功');
            } catch (error) {
                console.error('❌ 直接音频链连接失败:', error);
            }
        }
        console.log('🔗 音频链连接完成');
    }

    /**
     * 重新连接音频链 - 支持实时切换
     */
    reconnectAudioChain() {
        console.log('🔄 开始重新连接音频链（实时切换模式）...');
        console.log(`🔄 audioContext存在: ${!!this.audioContext}`);
        console.log(`🔄 gainNode存在: ${!!this.gainNode}`);
        console.log(`🔄 sourceNode存在: ${!!this.sourceNode}`);
        console.log(`🔄 equalizer存在: ${!!this.equalizer}`);
        console.log(`🔄 equalizerEnabled: ${this.equalizerEnabled}`);
        console.log(`🔄 isPlaying: ${this.isPlaying}`);

        if (!this.audioContext || !this.gainNode) {
            console.warn('⚠️ audioContext或gainNode不存在，无法重新连接音频链');
            return false;
        }

        if (!this.sourceNode) {
            console.warn('⚠️ sourceNode不存在，无法重新连接音频链');
            return false;
        }

        console.log('🔄 断开所有现有连接...');

        // 只断开必要的连接，避免破坏基础连接
        try {
            if (this.sourceNode) {
                this.sourceNode.disconnect();
                console.log('✅ sourceNode已断开');
            }
        } catch (error) {
            console.warn('⚠️ sourceNode断开失败:', error);
        }

        try {
            if (this.equalizer && this.equalizer.output) {
                this.equalizer.output.disconnect();
                console.log('✅ equalizer.output已断开');
            }
        } catch (error) {
            console.warn('⚠️ equalizer.output断开失败:', error);
        }

        // 断开gainNode的输入连接，但保持到destination的连接
        try {
            // 先断开所有连接，然后重新建立到destination的连接
            this.gainNode.disconnect();
            this.gainNode.connect(this.audioContext.destination);
            console.log('✅ gainNode重新连接到destination');
        } catch (error) {
            console.warn('⚠️ gainNode重连失败:', error);
        }

        console.log('🔄 开始重新连接...');

        // 重新连接音频路径
        try {
            if (this.equalizer && this.equalizerEnabled) {
                console.log('🔗 使用均衡器路径: sourceNode -> equalizer -> gainNode -> destination');

                // 均衡器输出 -> 增益节点
                this.equalizer.output.connect(this.gainNode);
                console.log('✅ equalizer.output -> gainNode 重新连接成功');

                // 音频源 -> 均衡器输入
                this.sourceNode.connect(this.equalizer.input);
                console.log('✅ sourceNode -> equalizer.input 重新连接成功');

            } else {
                console.log('🔗 使用直接路径: sourceNode -> gainNode -> destination');

                // 音频源 -> 增益节点
                this.sourceNode.connect(this.gainNode);
                console.log('✅ sourceNode -> gainNode 直接重新连接成功');
            }

            console.log('✅ 音频链实时重新连接完成');
            return true;

        } catch (error) {
            console.error('❌ 音频链重新连接失败:', error);

            // 尝试恢复基本连接
            try {
                console.log('🔄 尝试恢复基本音频连接...');
                this.sourceNode.disconnect();
                this.sourceNode.connect(this.gainNode);
                console.log('✅ 已恢复基本音频连接');
                return true;
            } catch (recoveryError) {
                console.error('❌ 恢复基本连接也失败:', recoveryError);
                return false;
            }
        }
    }

    /**
     * 销毁音频引擎
     */
    destroy() {
        this.stop();
        this.stopProgressTimer();

        // 清理封面URL
        this.cleanupCoverUrls();

        if (this.equalizer) {
            this.equalizer.destroy();
            this.equalizer = null;
        }

        if (this.audioContext) {
            this.audioContext.close();
        }

        console.log('🗑️ Web Audio Engine 已销毁');
    }
}

/**
 * 音频均衡器类
 * 10频段均衡器功能
 */
class AudioEqualizer {
    constructor(audioContext) {
        this.audioContext = audioContext;
        this.filters = [];
        this.input = null;
        this.output = null;

        // 10频段配置 (Hz)
        this.frequencies = [31, 62, 125, 250, 500, 1000, 2000, 4000, 8000, 16000];

        // 预设配置
        this.presets = {
            'flat': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            'pop': [1, 2, 3, 1, -1, -1, 1, 2, 3, 2],
            'rock': [3, 2, 1, 0, -1, 0, 1, 2, 3, 3],
            'classical': [2, 1, 0, 0, 0, 0, -1, -1, 0, 1],
            'jazz': [2, 1, 0, 1, 2, 1, 0, 1, 2, 2],
            'vocal': [0, -1, -2, -1, 1, 3, 3, 2, 1, 0],
            'bass': [4, 3, 2, 1, 0, -1, -2, -2, -1, 0],
            'treble': [0, -1, -2, -1, 0, 1, 2, 3, 4, 4],
            'electronic': [2, 3, 1, 0, -1, 1, 0, 1, 2, 3]
        };

        // 当前增益值 (dB)
        this.gains = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
        this.initialize();
    }

    /**
     * 初始化均衡器
     */
    initialize() {
        try {
            console.log('🎛️ 开始初始化音频均衡器...');
            console.log(`🎛️ audioContext存在: ${!!this.audioContext}`);
            console.log(`🎛️ audioContext状态: ${this.audioContext.state}`);

            // 创建输入和输出节点
            this.input = this.audioContext.createGain();
            this.output = this.audioContext.createGain();
            console.log('✅ 均衡器输入输出节点创建成功');
            console.log(`🎛️ input节点: ${!!this.input}`);
            console.log(`🎛️ output节点: ${!!this.output}`);

            // 创建滤波器链
            this.createFilterChain();

            console.log('✅ 音频均衡器初始化成功');
            console.log(`🎛️ 滤波器数量: ${this.filters.length}`);
        } catch (error) {
            console.error('❌ 音频均衡器初始化失败:', error);
            throw error;
        }
    }

    /**
     * 创建滤波器链
     */
    createFilterChain() {
        console.log('🔗 开始创建滤波器链...');
        console.log(`🔗 频段数量: ${this.frequencies.length}`);


        let previousNode = this.input;
        console.log(`🔗 起始节点: input (${!!this.input})`);

        for (let i = 0; i < this.frequencies.length; i++) {
            console.log(`🔗 创建第 ${i + 1} 个滤波器 (${this.frequencies[i]}Hz)...`);

            const filter = this.audioContext.createBiquadFilter();

            // 设置滤波器类型
            if (i === 0) {
                // 第一个频段使用低频搁架滤波器
                filter.type = 'lowshelf';
                console.log(`🔗 滤波器 ${i}: lowshelf`);
            } else if (i === this.frequencies.length - 1) {
                // 最后一个频段使用高频搁架滤波器
                filter.type = 'highshelf';
                console.log(`🔗 滤波器 ${i}: highshelf`);
            } else {
                // 中间频段使用峰值滤波器
                filter.type = 'peaking';
                console.log(`🔗 滤波器 ${i}: peaking`);
            }

            // 设置频率
            filter.frequency.value = this.frequencies[i];
            console.log(`🔗 滤波器 ${i} 频率设置: ${this.frequencies[i]}Hz`);

            // 设置Q值
            if (filter.type === 'peaking') {
                filter.Q.value = 1.0; // 峰值滤波器的Q值
                console.log(`🔗 滤波器 ${i} Q值: 1.0 (peaking)`);
            } else {
                filter.Q.value = 0.7; // 搁架滤波器的Q值
                console.log(`🔗 滤波器 ${i} Q值: 0.7 (shelf)`);
            }

            // 初始增益为0
            filter.gain.value = 0;
            console.log(`🔗 滤波器 ${i} 初始增益: 0dB`);

            try {
                // 连接到链中
                previousNode.connect(filter);
                console.log(`✅ 滤波器 ${i} 连接成功: ${previousNode === this.input ? 'input' : 'filter' + (i - 1)} -> filter${i}`);
                previousNode = filter;
            } catch (error) {
                console.error(`❌ 滤波器 ${i} 连接失败:`, error);
                throw error;
            }

            this.filters.push(filter);
        }

        try {
            // 连接到输出
            previousNode.connect(this.output);
            console.log(`✅ 最后一个滤波器连接到输出: filter${this.filters.length - 1} -> output`);
        } catch (error) {
            console.error('❌ 连接到输出失败:', error);
            throw error;
        }

        console.log('✅ 滤波器链创建完成');
        console.log(`🔗 滤波器链路径: input -> ${this.filters.length}个滤波器 -> output`);
    }

    /**
     * 设置频段增益
     * @param {number} bandIndex - 频段索引 (0-9)
     * @param {number} gain - 增益值 (dB, -12 到 +12)
     */
    setBandGain(bandIndex, gain) {
        console.log(`🎛️ 尝试设置频段 ${bandIndex} 增益为 ${gain}dB`);
        console.log(`🎛️ 滤波器数组长度: ${this.filters.length}`);

        if (bandIndex < 0 || bandIndex >= this.frequencies.length) {
            console.error('❌ 无效的频段索引:', bandIndex, '有效范围: 0-' + (this.frequencies.length - 1));
            return;
        }

        // 限制增益范围
        gain = Math.max(-12, Math.min(12, gain));

        // 更新增益值记录
        this.gains[bandIndex] = gain;

        // 如果滤波器存在，更新滤波器增益
        if (this.filters.length > 0 && this.filters[bandIndex]) {
            this.filters[bandIndex].gain.setValueAtTime(gain, this.audioContext.currentTime);
            console.log(`✅ 频段 ${this.frequencies[bandIndex]}Hz 滤波器增益设置为 ${gain}dB`);
        } else {
            console.log(`⚠️ 频段 ${bandIndex} 滤波器不存在（可能处于绕过模式），仅更新增益记录`);
        }
    }

    /**
     * 获取频段增益
     * @param {number} bandIndex - 频段索引
     * @returns {number} 增益值 (dB)
     */
    getBandGain(bandIndex) {
        if (bandIndex < 0 || bandIndex >= this.gains.length) {
            return 0;
        }
        return this.gains[bandIndex];
    }

    /**
     * 设置所有频段增益
     * @param {number[]} gains - 增益数组
     */
    setAllGains(gains) {
        if (!Array.isArray(gains) || gains.length !== this.frequencies.length) {
            console.error('❌ 无效的增益数组');
            return;
        }

        for (let i = 0; i < gains.length; i++) {
            this.setBandGain(i, gains[i]);
        }
    }

    /**
     * 获取所有频段增益
     * @returns {number[]} 增益数组
     */
    getAllGains() {
        return [...this.gains];
    }

    /**
     * 应用预设
     * @param {string} presetName - 预设名称
     */
    applyPreset(presetName) {
        if (!this.presets[presetName]) {
            console.error('❌ 未知的预设:', presetName);
            return false;
        }

        this.setAllGains(this.presets[presetName]);
        console.log(`🎵 已应用预设: ${presetName}`);
        return true;
    }

    /**
     * 获取可用预设列表
     * @returns {string[]} 预设名称数组
     */
    getPresetNames() {
        return Object.keys(this.presets);
    }

    /**
     * 重置所有频段为平坦响应
     */
    reset() {
        this.setAllGains([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
        console.log('🔄 均衡器已重置');
    }

    /**
     * 断开所有连接
     */
    disconnect() {
        console.log('🔌 开始断开均衡器所有连接...');

        try {
            if (this.input) {
                this.input.disconnect();
                console.log('✅ 均衡器input节点已断开');
            }
        } catch (error) {
            console.warn('⚠️ 均衡器input节点断开失败:', error);
        }

        try {
            if (this.output) {
                this.output.disconnect();
                console.log('✅ 均衡器output节点已断开');
            }
        } catch (error) {
            console.warn('⚠️ 均衡器output节点断开失败:', error);
        }

        this.filters.forEach((filter, index) => {
            try {
                filter.disconnect();
                console.log(`✅ 滤波器 ${index} 已断开`);
            } catch (error) {
                console.warn(`⚠️ 滤波器 ${index} 断开失败:`, error);
            }
        });

        console.log('🔌 均衡器所有连接断开完成');
    }

    /**
     * 销毁均衡器
     */
    destroy() {
        this.disconnect();
        this.filters = [];
        this.input = null;
        this.output = null;
        console.log('🗑️ 音频均衡器已销毁');
    }
}

// 导出音频引擎和均衡器
window.WebAudioEngine = WebAudioEngine;
window.AudioEqualizer = AudioEqualizer;
